{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 332,
   "id": "0dfdf565-ac08-470c-9b6c-5b7b7f7f6376",
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports \n",
    "import os\n",
    "import json\n",
    "import operator\n",
    "import pandas as pd\n",
    "from io import StringIO\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "\n",
    "# Players\n",
    "BotHash = \"FDDD772696374FE2C5F932BB598533D9\"\n",
    "SB = 10\n",
    "Players = [\n",
    "   {\n",
    "        'Name': 'Bold',\n",
    "        'games': 'Bold'\n",
    "    },\n",
    "    {\n",
    "        'Name': 'FoldMan',\n",
    "        'games': 'FoldMan'\n",
    "    },\n",
    "    {\n",
    "        'Name': 'Fish',\n",
    "       'games': 'Fish'\n",
    "    },\n",
    "     {\n",
    "        'Name': 'Random',\n",
    "        'games': 'Random',\n",
    "    },\n",
    "    {\n",
    "        'Name': 'HonestMan',\n",
    "        'games':'HonestMan',\n",
    "    }\n",
    "]\n",
    "\n",
    "def prettyPrint(*arguments):\n",
    "    out = ''\n",
    "    for arg in arguments:\n",
    "        space = (30-len(arg)) * \" \"\n",
    "        out += arg + space\n",
    "    print(out)\n",
    "    \n",
    "# Load file paths of player games.\n",
    "def LoadPlayerGames(player):\n",
    "    #return [os.path.join(r,file) for r,d,f in os.walk(player['games']) for file in f]\n",
    "    return [os.path.join(player['games'],f) for f in os.listdir(player['games']) if not f.startswith('.')]\n",
    "\n",
    "# Load game as json object.\n",
    "def LoadGame(path):\n",
    "    with open(path) as f:\n",
    "        g = json.load(f)\n",
    "        if g[\"BotHash\"] != BotHash:\n",
    "            raise Exception(\"BotHash does not match: \" + g[\"BotHash\"])\n",
    "        return g\n",
    "\n",
    "# Get player result from game (W,D,L)\n",
    "def GetGameResultForPlayer(game, playerName):\n",
    "    results = game[\"Results\"]\n",
    "    maxStack = 0\n",
    "    hasMax = []\n",
    "    # find max stack\n",
    "    for result in results:\n",
    "        if maxStack < result[\"Stack\"]:\n",
    "            maxStack = result[\"Stack\"]\n",
    "            hasMax= [result[\"Player\"][\"Name\"]]\n",
    "        elif maxStack == result[\"Stack\"]:\n",
    "            hasMax.append(result[\"Player\"][\"Name\"])\n",
    "    # find player result\n",
    "    if playerName in hasMax:\n",
    "        if len(hasMax) > 1:\n",
    "            return 'D'\n",
    "        else:\n",
    "            return 'W'\n",
    "    return 'L'\n",
    "            \n",
    "# Get player results against opponent\n",
    "def GetPlayerGamesResults(playerName, opponent):\n",
    "    won = 0\n",
    "    lost = 0\n",
    "    drew = 0\n",
    "    files = LoadPlayerGames(opponent)\n",
    "    for file in files:\n",
    "        game = LoadGame(file)\n",
    "        result = GetGameResultForPlayer(game, playerName)\n",
    "        if result == 'W':\n",
    "            won += 1\n",
    "        elif result == 'D':\n",
    "            drew += 1\n",
    "        elif result == 'L':\n",
    "            lost += 1\n",
    "        else:\n",
    "            raise Exception(\"Error :(\")\n",
    "    return (won, drew, lost)\n",
    "\n",
    "# Get player result from round (W,D,L)\n",
    "def GetRoundResultForPlayer(r, playerName):\n",
    "    results = r[\"Winner\"]\n",
    "    winners = len(results)\n",
    "    won = False\n",
    "    for result in results:\n",
    "        if playerName == result[\"Name\"]:\n",
    "            won = True\n",
    "            break\n",
    "    if won:\n",
    "        if winners > 1:\n",
    "            return 'D'\n",
    "        else:\n",
    "            return 'W'\n",
    "    return 'L'\n",
    "\n",
    "# Get player round results from game\n",
    "def GetRoundResultsForPlayer(game, playerName):\n",
    "    won = 0\n",
    "    lost = 0\n",
    "    drew = 0\n",
    "    for r in game[\"Rounds\"]:\n",
    "        result = GetRoundResultForPlayer(r, playerName)\n",
    "        if result == 'W':\n",
    "            won += 1\n",
    "        elif result == 'D':\n",
    "            drew += 1\n",
    "        elif result == 'L':\n",
    "            lost += 1\n",
    "        else:\n",
    "            raise Exception(\"Error :(\")\n",
    "    return (won, drew, lost)\n",
    "\n",
    "# Get player round results against an opponent\n",
    "def GetPlayerRoundResults(playerName, opponent):\n",
    "    won = 0\n",
    "    lost = 0\n",
    "    drew = 0\n",
    "    files = LoadPlayerGames(opponent)\n",
    "    for file in files:\n",
    "        game = LoadGame(file)\n",
    "        w,d,l = GetRoundResultsForPlayer(game, playerName)\n",
    "        won += w\n",
    "        drew += d\n",
    "        lost += l\n",
    "    return (won, drew, lost)\n",
    "\n",
    "def GetPlayerPlayingStyle(opponent,playerName):\n",
    "    playerModel = {\n",
    "        'LooseAggressive': 0,\n",
    "        'LoosePassive': 0,\n",
    "        'TightAggressive': 0,\n",
    "        'TightPassive': 0,\n",
    "        'Balanced' : 0,\n",
    "    }\n",
    "    opponentModel = {\n",
    "        'LooseAggressive': 0,\n",
    "        'LoosePassive': 0,\n",
    "        'TightAggressive': 0,\n",
    "        'TightPassive': 0,\n",
    "        'Balanced' : 0,\n",
    "    }\n",
    "    \n",
    "    files = LoadPlayerGames(opponent)\n",
    "    for file in files:\n",
    "        game = LoadGame(file)\n",
    "        models = game[\"PlayerModels\"]\n",
    "        for m in models:\n",
    "            if m[\"Player\"][\"Name\"] == playerName:\n",
    "                playerModel[m[\"PlayingStyle\"]] +=1\n",
    "            if m[\"Player\"][\"Name\"] == opponent[\"Name\"]:\n",
    "                opponentModel[m[\"PlayingStyle\"]] +=1\n",
    "    return (max(playerModel.items(), key=operator.itemgetter(1))[0], max(opponentModel.items(), key=operator.itemgetter(1))[0])\n",
    "\n",
    "    \n",
    "def GetWPH(playerName, opponent, rn):\n",
    "    stackSum = 0\n",
    "    initStack = 0\n",
    "    files = LoadPlayerGames(opponent)\n",
    "    for file in files:\n",
    "        game = LoadGame(file)\n",
    "        for r in game[\"Results\"]:\n",
    "            if playerName == r[\"Player\"][\"Name\"]:\n",
    "                stackSum += r[\"Stack\"]\n",
    "                initStack += r[\"InitialStack\"]\n",
    "                break\n",
    "    return (stackSum-initStack)/rn\n",
    "\n",
    "\n",
    "def GetFWPHForPlayer(game, playerName):\n",
    "    loss = 0\n",
    "    rn = len(game[\"Rounds\"])\n",
    "    for r in game[\"Rounds\"]:\n",
    "        sbp = r[\"SmallBlindPosition\"]\n",
    "        bbp = r[\"BigBlindPosition\"]\n",
    "        if r[\"Players\"][sbp][\"Name\"] == playerName:\n",
    "            loss -= SB\n",
    "        if r[\"Players\"][bbp][\"Name\"] == playerName:\n",
    "            loss -= SB * 2\n",
    "    return loss/rn\n",
    "\n",
    "def GetFWPH(playerName, opponent):\n",
    "    files = LoadPlayerGames(opponent)\n",
    "    fwphSum = 0\n",
    "    gn = len(files)\n",
    "    for file in files:\n",
    "        game = LoadGame(file)\n",
    "        fwphSum += GetFWPHForPlayer(game, playerName)\n",
    "    return fwphSum/gn   \n",
    "\n",
    "def AdjustedWPH(wph, fwph):\n",
    "    return wph - fwph\n",
    "\n",
    "\n",
    "# heat map\n",
    "def DrawWeightTable(playerModel):\n",
    "    csvStringIO = StringIO(playerModel[\"WeightTable\"])\n",
    "    df = pd.read_csv(csvStringIO, header = None, names=[\"A\", \"K\", \"Q\", \"J\", \"T\", \"9\", \"8\", \"7\", \"6\", \"5\", \"4\", \"3\", \"2\"])\n",
    "    # Displaying dataframe as an heatmap\n",
    "    # with diverging colourmap as Greys\n",
    "    plt.imshow(df, cmap=\"Greys\",vmin=0,vmax=1) \n",
    "\n",
    "    # Displaying a color bar to understand\n",
    "    # which color represents which range of data\n",
    "    plt.colorbar()\n",
    "\n",
    "    # ticks style\n",
    "    plt.rcParams['xtick.top'] = plt.rcParams['xtick.labeltop'] = True\n",
    "    plt.rcParams['xtick.bottom'] = plt.rcParams['xtick.labelbottom'] = False\n",
    "\n",
    "    plt.rcParams['ytick.right'] = plt.rcParams['ytick.labelright'] = False\n",
    "    plt.rcParams['ytick.left'] = plt.rcParams['ytick.labelleft'] = True\n",
    "\n",
    "    # title\n",
    "    #plt.xlabel(\"Hand Strength Adjustment metrix\")\n",
    "\n",
    "    # Assigning labels of x-axis \n",
    "    # according to dataframe\n",
    "    plt.xticks(range(len(df)), df.columns)\n",
    "\n",
    "    # Assigning labels of y-axis \n",
    "    # according to dataframe\n",
    "    plt.yticks(range(len(df)), [\"A\", \"K\", \"Q\", \"J\", \"T\", \"9\", \"8\", \"7\", \"6\", \"5\", \"4\", \"3\", \"2\"])\n",
    "\n",
    "\n",
    "    # Displaying the figure\n",
    "    plt.show()\n",
    "\n",
    "# print results\n",
    "def PrintResultOf(playerName):\n",
    "    for player in Players:\n",
    "        prettyPrint(\"Results against:\", player[\"Name\"])\n",
    "        n = len(LoadPlayerGames(player))\n",
    "        w,d,l = GetPlayerGamesResults(playerName, player)\n",
    "        # game states\n",
    "        prettyPrint(\"number of games:\",str(n))\n",
    "        prettyPrint(\"number of games won:\", str(w) , \"{:.1f}\".format(w*100/n) + \"%\")\n",
    "        prettyPrint(\"number of games drew:\", str(d), \"{:.1f}\".format(d*100/n) + \"%\")\n",
    "        prettyPrint(\"number of games lost:\", str(l), \"{:.1f}\".format(l*100/n) + \"%\")\n",
    "        # round states\n",
    "        rw,rd,rl = GetPlayerRoundResults(playerName, player)\n",
    "        rn = rw+rd+rl\n",
    "        prettyPrint(\"number of rounds:\",str(rn))\n",
    "        prettyPrint(\"number of rounds won:\", str(rw) , \"{:.1f}\".format(rw*100/rn) + \"%\")\n",
    "        prettyPrint(\"number of rounds drew:\", str(rd), \"{:.1f}\".format(rd*100/rn) + \"%\")\n",
    "        prettyPrint(\"number of rounds lost:\", str(rl), \"{:.1f}\".format(rl*100/rn) + \"%\")\n",
    "        # wph\n",
    "        wph = GetWPH(playerName, player, rn)\n",
    "        fwph = GetFWPH(playerName, player)\n",
    "        prettyPrint(\"WPH:\", \"{:.1f}\".format(wph))\n",
    "        prettyPrint(\"FWPH:\", \"{:.1f}\".format(fwph))\n",
    "        prettyPrint(\"AWPH:\", \"{:.1f}\".format(AdjustedWPH(wph, fwph)))\n",
    "        # playing style\n",
    "        ps, os = GetPlayerPlayingStyle(player,playerName)\n",
    "        prettyPrint(playerName + \" Playing Style:\", ps)\n",
    "        prettyPrint(player[\"Name\"] + \" Playing Style:\", os)\n",
    "        # player models\n",
    "        files = LoadPlayerGames(player)\n",
    "        game = LoadGame(random.choice(files))\n",
    "        for model in game[\"PlayerModels\"]:\n",
    "            if model[\"Player\"][\"Name\"] == playerName:\n",
    "                continue\n",
    "            DrawWeightTable(model)\n",
    "        print('-------------------------------------------------------------')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "id": "b881f708-89b4-4bfe-af46-04c331654c78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results against:              Bold                          \n",
      "number of games:              100                           \n",
      "number of games won:          47                            47.0%                         \n",
      "number of games drew:         0                             0.0%                          \n",
      "number of games lost:         53                            53.0%                         \n",
      "number of rounds:             632                           \n",
      "number of rounds won:         117                           18.5%                         \n",
      "number of rounds drew:        0                             0.0%                          \n",
      "number of rounds lost:        515                           81.5%                         \n",
      "WPH:                          -9.5                          \n",
      "FWPH:                         -15.6                         \n",
      "AWPH:                         6.1                           \n",
      "PokerShark Playing Style:     TightPassive                  \n",
      "Bold Playing Style:           LooseAggressive               \n",
      "Bold\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n",
      "Results against:              FoldMan                       \n",
      "number of games:              100                           \n",
      "number of games won:          100                           100.0%                        \n",
      "number of games drew:         0                             0.0%                          \n",
      "number of games lost:         0                             0.0%                          \n",
      "number of rounds:             6700                          \n",
      "number of rounds won:         6700                          100.0%                        \n",
      "number of rounds drew:        0                             0.0%                          \n",
      "number of rounds lost:        0                             0.0%                          \n",
      "WPH:                          14.9                          \n",
      "FWPH:                         -15.1                         \n",
      "AWPH:                         30.0                          \n",
      "PokerShark Playing Style:     LooseAggressive               \n",
      "FoldMan Playing Style:        TightPassive                  \n",
      "FoldMan\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n",
      "Results against:              Fish                          \n",
      "number of games:              100                           \n",
      "number of games won:          81                            81.0%                         \n",
      "number of games drew:         0                             0.0%                          \n",
      "number of games lost:         19                            19.0%                         \n",
      "number of rounds:             886                           \n",
      "number of rounds won:         362                           40.9%                         \n",
      "number of rounds drew:        7                             0.8%                          \n",
      "number of rounds lost:        517                           58.4%                         \n",
      "WPH:                          70.0                          \n",
      "FWPH:                         -15.3                         \n",
      "AWPH:                         85.2                          \n",
      "PokerShark Playing Style:     LooseAggressive               \n",
      "Fish Playing Style:           LoosePassive                  \n",
      "Fish\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n",
      "Results against:              Random                        \n",
      "number of games:              100                           \n",
      "number of games won:          41                            41.0%                         \n",
      "number of games drew:         0                             0.0%                          \n",
      "number of games lost:         59                            59.0%                         \n",
      "number of rounds:             3739                          \n",
      "number of rounds won:         1457                          39.0%                         \n",
      "number of rounds drew:        1                             0.0%                          \n",
      "number of rounds lost:        2281                          61.0%                         \n",
      "WPH:                          -3.9                          \n",
      "FWPH:                         -15.3                         \n",
      "AWPH:                         11.3                          \n",
      "PokerShark Playing Style:     TightPassive                  \n",
      "Random Playing Style:         LooseAggressive               \n",
      "Random\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n",
      "Results against:              HonestMan                     \n",
      "number of games:              100                           \n",
      "number of games won:          88                            88.0%                         \n",
      "number of games drew:         0                             0.0%                          \n",
      "number of games lost:         12                            12.0%                         \n",
      "number of rounds:             4663                          \n",
      "number of rounds won:         3694                          79.2%                         \n",
      "number of rounds drew:        7                             0.2%                          \n",
      "number of rounds lost:        962                           20.6%                         \n",
      "WPH:                          15.6                          \n",
      "FWPH:                         -14.9                         \n",
      "AWPH:                         30.5                          \n",
      "PokerShark Playing Style:     LooseAggressive               \n",
      "HonestMan Playing Style:      TightPassive                  \n",
      "HonestMan\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "PrintResultOf('PokerShark')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fe6a05e-3960-4da8-a998-fbf35013dba2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
